UTSChatAdapter/UTSChatAdapter/main.swift (1)

3-19: Add proper resource management and timeout handling

The WebSocket connection needs proper lifecycle management and timeout handling for RPC calls.

Consider these improvements:

1. Add timeout handling for RPC calls
2. Implement proper WebSocket cleanup
3. Add connection health checks

Example implementation structure:

func serve() async throws {
    let webSocket = await WebSocketWrapper()
    var adapter = await ChatAdapter(webSocket: webSocket)
    
    // Add connection health check
    let healthCheckTask = Task {
        while true {
            try await Task.sleep(nanoseconds: 30_000_000_000) // 30 seconds
            try await webSocket.ping()
        }
    }
    
    defer {
        healthCheckTask.cancel()
        try? await webSocket.close()
    }
    
    try await withTimeout(seconds: 300) { // 5 minute timeout
        try await webSocket.start { message in
            // ... existing message handling ...
        }
    }
}

Sources/AblyChat/ChatClient.swift (1)

30-32: Document the fallback behavior for clientID.

While the implementation is functional, the fallback value "" should be documented. Consider:

1. Using a more meaningful default or making it configurable
2. Adding documentation explaining the fallback behavior

Consider this enhancement:

+/// The ID of the connected client.
+/// Returns the Ably client ID if available, otherwise falls back to "<Noname>".
 public nonisolated var clientID: String {
     realtime.clientId ?? "<Noname>"
 }

UTSChatAdapter/UTSChatAdapter/NanoID.swift (3)

1-6: Update the copyright notice

The copyright notice is outdated. Consider updating it to reflect the current year and organization.

-//  Copyright © 2018 Anton Lovchikov. All rights reserved.
+//  Copyright © 2024 Ably. All rights reserved.

---

10-25: Enhance documentation with Swift-style doc comments

Consider using Swift's documentation style with /// for better IDE integration and documentation generation.

-/// USAGE
-///
-/// Nano ID with default alphabet (0-9a-zA-Z_~) and length (21 chars)
-/// let id = NanoID.new()
+/// A utility for generating unique identifiers based on the Nano ID specification.
+///
+/// Example usage:
+/// ```swift
+/// // Generate with default alphabet (0-9a-zA-Z_~) and length (21 chars)
+/// let id = NanoID.new()
+///
+/// // Generate with default alphabet and custom length
+/// let id = NanoID.new(12)
+///
+/// // Generate with custom alphabet and length
+/// let id = NanoID.new(alphabet: .uppercasedLatinLetters, size: 15)
+///
+/// // Create a reusable generator with custom parameters
+/// let generator = NanoID(alphabet: .lowercasedLatinLetters, .numbers, size: 10)
+/// let id1 = generator.new()
+/// let id2 = generator.new()
+/// ```

---

98-125: Improve enum implementation and efficiency

The current implementation has a few areas for improvement:

1. Remove unnecessary default case in chars()
2. Optimize urlSafe case implementation
3. Consider using static stored properties for character sets

 enum NanoIDAlphabet {
+    // Static character sets for better performance
+    private static let uppercased = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    private static let lowercased = "abcdefghijklmnopqrstuvwxyz"
+    private static let numeric = "1234567890"
+    private static let special = "~_"
+    
     case urlSafe
     case uppercasedLatinLetters
     case lowercasedLatinLetters
     case numbers
     
     func toString() -> String {
         switch self {
         case .uppercasedLatinLetters, .lowercasedLatinLetters, .numbers:
             return self.chars()
         case .urlSafe:
-            return ("\(NanoIDAlphabet.uppercasedLatinLetters.chars())\(NanoIDAlphabet.lowercasedLatinLetters.chars())\(NanoIDAlphabet.numbers.chars())~_")
+            // Pre-computed string is more efficient
+            return NanoIDAlphabet.uppercased + NanoIDAlphabet.lowercased + NanoIDAlphabet.numeric + NanoIDAlphabet.special
         }
     }
     
     private func chars() -> String {
         switch self {
         case .uppercasedLatinLetters:
-            return "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            return NanoIDAlphabet.uppercased
         case .lowercasedLatinLetters:
-            return "abcdefghijklmnopqrstuvwxyz"
+            return NanoIDAlphabet.lowercased
         case .numbers:
-            return "1234567890"
-        default:
-            return ""
+            return NanoIDAlphabet.numeric
         }
     }
 }

Sources/AblyChat/Errors.swift (1)

Line range hint 39-56: Consider enhancing the error handling robustness.

The status code implementation could be improved in several ways:

1. Add a default case to the switch statement to handle future error codes
2. Define status code constants instead of using magic numbers (400, 500)
3. Consider adding error code ranges validation to ensure no overlaps

internal var statusCode: Int {
    switch self {
    case .inconsistentRoomOptions,
         .messagesDetachmentFailed,
         .presenceDetachmentFailed,
         .reactionsDetachmentFailed,
         .occupancyDetachmentFailed,
         .typingDetachmentFailed,
         .roomInFailedState,
         .roomIsReleasing,
         .roomIsReleased:
-        400
+        StatusCode.badRequest
    case .messagesAttachmentFailed,
         .presenceAttachmentFailed,
         .reactionsAttachmentFailed,
         .occupancyAttachmentFailed,
         .typingAttachmentFailed:
-        500
+        StatusCode.serverError
+    @unknown default:
+        StatusCode.serverError
    }
}

private enum StatusCode {
    static let badRequest = 400
    static let serverError = 500
}

Sources/AblyChat/DefaultMessages.swift (1)

47-47: LGTM! Improved subscription initialization.

The simplified subscription point initialization with guaranteed timeserial value (even if empty) makes the code more predictable and aligns well with the CHA-M4a requirement for subscription registration.

This change reduces complexity and potential race conditions by removing async operations from the subscription initialization path.

UTSChatAdapter/UTSChatAdapter/WebSocketWrapper.swift (1)

10-10: Consider making the WebSocket URL configurable

Hardcoding the WebSocket URL limits flexibility and complicates deployment across different environments (development, staging, production). Consider injecting the URL as a parameter, reading it from a configuration file, or using environment variables to make it configurable.

UTSChatAdapter/UTSChatAdapter/Schema+Adjustments.swift (2)

16-16: Clarify the purpose of the empty PresenceDataWrapper struct

The PresenceDataWrapper struct is currently empty. If it serves as a placeholder or marker, consider adding a comment to clarify its intended use. Otherwise, if it's unnecessary, you might remove it.

---

77-77: Consider converting options() method to a computed property

In the Room extension, func options() -> RoomOptions { options } could be more idiomatically written as a computed property for better readability.

Apply this diff to refactor:

-extension Room {
-    func options() -> RoomOptions { options }
+extension Room {
+    var options: RoomOptions { 
+        options 
+    }

UTSChatAdapter/UTSChatAdapter/Utils.swift (2)

303-314: Improve type handling in PresenceDataWrapper.from

The current implementation checks for specific dictionary types and then force casts. This can be error-prone and inflexible.

Refactor the method to handle various types more elegantly:

static func from(_ value: Any?) -> PresenceData {
    if let data = value as? PresenceData {
        return data
    } else if let stringValue = value as? String {
        return stringValue
    } else {
        return "" // Or handle default case appropriately
    }
}

---

262-271: Handle unexpected log level strings gracefully

In LogLevel.from(string:), an unknown string defaults to .debug, which might not be the intended behavior.

Consider adding a default case that handles unexpected values explicitly:

static func from(string: String) -> Self {
    switch string.lowercased() {
    case "trace": return .trace
    case "debug": return .debug
    case "info": return .info
    case "warn": return .warn
    case "error": return .error
    case "silent": return .silent
    default:
        print("Unknown log level '\(string)'; defaulting to .debug")
        return .debug
    }
}

UTSChatAdapter/UTSChatAdapter/ChatAdapterGenerator.swift (4)

213-214: Clarify the comment regarding simplification to one callback parameter.

The comment // code below simplifies it to just one callback parameter (line 213) indicates an intentional limitation. However, this may not be sufficient for all use cases where callbacks have multiple parameters.

Consider updating the comment to explain why only one parameter is handled or refactor the code to support multiple callback parameters.

---

39-42: Provide custom implementations or address unimplemented paths.

In several methods, you check if a given implPath is in Schema.skipPaths and print a message indicating that it is not yet implemented or requires custom implementation. Examples:

• Lines 39-42 in generateConstructorForType
• Lines 66-70 in generateMethodForType
• Lines 126-133 in generateFieldForType
• Lines 169-173 in generateMethodWithCallbackForType

Consider implementing these paths or providing a mechanism to handle unimplemented methods to prevent incomplete code generation. You may also raise warnings or errors during generation to alert developers.

Also applies to: 66-70, 126-133, 169-173

---

94-116: Simplify result handling logic in generateMethodForType.

The current implementation has nested conditions to handle different result types. This could be simplified for better readability.

Refactor the result handling by using a switch-case or strategy pattern to manage different result scenarios more cleanly.

---

8-8: Consider initializing generatedFileContent using a StringBuilder.

Accumulating strings using += can lead to performance issues for large content.

In Swift, while there's no built-in StringBuilder, consider collecting the generated lines in an array and joining them at the end:

var generatedLines: [String] = ["// GENERATED CONTENT BEGIN\n"]
...
generatedFileContent = generatedLines.joined(separator: "\n")

UTSChatAdapter/UTSChatAdapter/Schema.swift (1)

15-994: Consider externalizing the schema content for better maintainability

Embedding a large JSON schema directly within the code can make the file lengthy and harder to manage. Consider loading the schema from an external file or resource to improve maintainability and readability.

For example, you could place the JSON schema in a file like Schema.json and load it as follows:

static var json: [JSON] {
    guard let url = Bundle.main.url(forResource: "Schema", withExtension: "json"),
          let data = try? Data(contentsOf: url) else {
        print("Failed to load schema JSON file.")
        return []
    }
    do {
        if let jsonArray = try JSONSerialization.jsonObject(with: data) as? [JSON] {
            return jsonArray
        } else {
            print("Schema JSON is not an array of JSON objects.")
            return []
        }
    } catch {
        print("Couldn't parse schema JSON: \(error.localizedDescription)")
        return []
    }
}

UTSChatAdapter/UTSChatAdapter/ChatAdapter.swift (1)

44-775: Refactor handleRpcCall method to improve maintainability

The handleRpcCall function is over 700 lines long and contains a large switch statement handling numerous cases. This can make the method difficult to read and maintain.

Consider refactoring the handleRpcCall function by extracting each case into its own method. This will enhance code modularity and readability.

Example:

mutating func handleRpcCall(rpcParams: JSON) async throws -> String {
    do {
        let method = try rpcParams.method()
        switch method {
        case "ChatClient#rooms":
            return try await handleChatClientRooms(rpcParams)
        // Other cases...
        default:
            return try handleDefaultCase(rpcParams, method: method)
        }
    } catch {
        // Error handling
    }
}

func handleChatClientRooms(_ rpcParams: JSON) async throws -> String {
    // Implementation of the "ChatClient#rooms" case
}

func handleDefaultCase(_ rpcParams: JSON, method: String) throws -> String {
    logger.warning("Method '\(method)' was not found")
    return jsonRpcError(try rpcParams.requestId(), error: AdapterError.methodNotFound(method))
}

By separating the logic, you can also unit test each handler method individually, improving code quality.

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Check the status of the referenced issue
gh issue view 10 --repo ably-labs/ably-chat-swift --json state,title,body

#!/bin/bash
# Description: Check how NanoID is used in the chat adapter

# Search for NanoID usage
echo "Searching for NanoID usage patterns..."
rg -A 5 "NanoID" --type swift

# Check for potential threading issues
echo "Checking for main thread usage..."
rg "DispatchQueue.main" --type swift -C 3

#!/bin/bash
# Search for any concurrent/async usage contexts around NanoID
echo "Searching for concurrent contexts..."
rg -B 3 -A 3 "async|concurrent|Thread|queue|sync" --type swift

# Search for actual NanoID instantiations
echo "Searching for NanoID instantiations..."
rg "NanoID\(" --type swift -C 3

# Search for generateId usage
echo "Searching for generateId usage..."
rg "generateId\(\)" --type swift -C 3

#!/bin/bash
# Search for any usage of the old error code value
rg -l "inconsistentRoomOptions.*=.*1" || echo "No occurrences of old error code found"

# Search for error handling code that might be affected
ast-grep --pattern 'switch $_ {
  case $inconsistentRoomOptions:
    $$$
}'

#!/bin/bash
# Search for any references to inconsistentRoomOptions
rg "inconsistentRoomOptions" -A 3 -B 3

# Search for error codes in the 102xxx range to verify the pattern
rg "[^0-9]102[0-9]{3}" -A 1 -B 1

# Look for any error handling or switch statements with this error
rg "case.*inconsistentRoomOptions" -A 3 -B 3

# Check git history for this error code
git log -p | rg "inconsistentRoomOptions"

#!/bin/bash
# Description: Verify the existence of `subscribe(events:)` in `Presence`.

# Search for `subscribe(events:)` method in Presence.swift files
fd -e swift -x grep -H 'func subscribe(events: ' {}

#!/bin/bash
# Description: Verify that `Message` has `isBefore`, `isAfter`, and `isEqual` methods.

# Search for method definitions in Message.swift files
fd -e swift -x grep -H -E 'func isBefore|func isAfter|func isEqual' {}

#!/bin/bash
# Search for Message class and its method definitions
rg -A 10 "class Message" --type swift

# Also search for protocol definitions that might declare these methods
rg -A 10 "protocol.*Message" --type swift

# Search for these specific method names with more context
rg "(isBefore|isAfter|isEqual).*Message" --type swift -A 2 -B 2

guard let json = json else {
    throw RPCError.invalidJSON
}

UTSChatAdapter/Sources/Generator/main.swift (1)

1-1: Consider adding a runtime mode check.

Since the PR instructions mention disabling the generate option in the project scheme, it would be helpful to have a clear separation between generation and runtime modes.

Consider implementing a mode check:

+// Check if running in generation mode
+let isGenerationMode = ProcessInfo.processInfo.environment["GENERATION_MODE"] == "1"
+
+guard isGenerationMode else {
+    print("Generation mode is disabled. Skipping generation.")
+    exit(0)
+}
+
 do {
     print("Starting chat adapter generation...")
     try ChatAdapterGenerator().generate()
     print("Chat adapter generation completed successfully")
 } catch {
     print("Failed to generate chat adapter: \(error)")
     exit(1)
 }

This way, you can control the generation through an environment variable instead of modifying the scheme settings.

UTSChatAdapter/Sources/Generator/Utils.swift (2)

3-3: Consider using Codable for type-safe JSON handling.

While [String: Any] is flexible, it bypasses Swift's type system and can lead to runtime errors. Consider using Codable protocol for safer JSON handling where possible.

Example of a type-safe approach:

struct SafeJSON: Codable {
    private let storage: [String: AnyCodable]
    
    // Add type-safe accessors here
}

// Use for dynamic values that must be preserved
struct AnyCodable: Codable {
    let value: Any
    
    // Implementation details...
}

---

5-8: Add documentation and handle edge cases.

The string transformation methods could benefit from documentation and edge case handling.

Consider this improved implementation:

 extension StringProtocol {
+    /// Converts the first character of the string to lowercase
+    /// - Returns: A new string with the first character in lowercase, or the original string if empty
     func firstLowercased() -> String {
-        prefix(1).lowercased() + dropFirst()
+        guard !isEmpty else { return String(self) }
+        return prefix(1).lowercased() + dropFirst()
     }
 
+    /// Converts the first character of the string to uppercase
+    /// - Returns: A new string with the first character in uppercase, or the original string if empty
     func firstUppercased() -> String {
-        prefix(1).uppercased() + dropFirst()
+        guard !isEmpty else { return String(self) }
+        return prefix(1).uppercased() + dropFirst()
     }
 }

UTSChatAdapter/Sources/Adapter/main.swift (2)

21-27: Improve main execution block with proper signal handling and error codes

The main execution block should handle system signals and provide more specific error codes.

Here's a suggested improvement:

+enum ExitCode: Int32 {
+    case success = 0
+    case connectionError = 1
+    case rpcError = 2
+    case unexpectedError = 3
+}
+
+func setupSignalHandling() {
+    signal(SIGTERM) { _ in
+        print("Received SIGTERM, shutting down...")
+        exit(ExitCode.success.rawValue)
+    }
+}
+
+setupSignalHandling()
+
 do {
     try await serve()
 }
 catch {
-    print("Exiting due to fatal error: \(error)") // TODO: replace with logger
-    exit(1)
+    let exitCode: ExitCode
+    switch error {
+    case is WebSocketError:
+        exitCode = .connectionError
+    case is JsonRpcError:
+        exitCode = .rpcError
+    default:
+        exitCode = .unexpectedError
+    }
+    print("Exiting due to fatal error: \(error)") // TODO: replace with logger
+    exit(exitCode.rawValue)
 }

---

16-16: Replace print statements with proper logging framework

The current implementation uses print statements with TODO comments. Consider implementing a proper logging strategy.

Consider the following recommendations:

1. Use a logging framework (e.g., SwiftyBeaver, CocoaLumberjack)
2. Implement different log levels (debug, info, error)
3. Include contextual information (timestamp, correlation ID)
4. Configure log destinations (console, file, remote)

Would you like me to provide an example implementation of a logging service?

Also applies to: 25-25

UTSChatAdapter/Sources/Adapter/Schema+Adapter.swift (5)

4-5: Consider consolidating error type aliases.

Having both ErrorInfo and AblyErrorInfo as aliases for the same type (ARTErrorInfo) could lead to confusion. Consider using just one of these aliases consistently throughout the codebase.

 typealias ErrorInfo = ARTErrorInfo
-typealias AblyErrorInfo = ARTErrorInfo

---

16-16: Document the purpose of empty struct.

The PresenceDataWrapper struct is currently empty. Please add documentation explaining its intended purpose and future implementation plans, or remove if not needed.

---

18-30: Add documentation for public methods and error handling.

The public methods before, after, and equal should include:

• Documentation explaining their behavior
• The conditions under which errors are thrown
• Examples of usage

Also, consider using more descriptive method names than isBefore, isAfter, and isEqual for the internal implementations.

---

32-34: Consider removing redundant wrapper method.

The options() method appears to be a simple wrapper around the options property. Unless there's a specific reason for this indirection (e.g., future validation or transformation), consider using the property directly.

---

36-42: Simplify extension and add documentation for async methods.

The extension appears to contain unnecessary wrapper methods. Consider:

1. Using properties directly instead of wrapper methods for hasNext and isLast
2. Adding documentation for async methods explaining:
   • Possible error conditions
   • When nil might be returned
   • Performance implications

UTSChatAdapter/Sources/Adapter/NanoID.swift (2)

64-96: Optimize string generation performance.

The current implementation uses string concatenation in a loop which can be inefficient for large IDs. Consider using String.UnicodeScalarView or pre-allocated array for better performance.

Here's an optimized version:

     static func generate(from alphabet: String, of length: Int) -> String {
-        var nanoID = ""
+        var scalars = Array<UnicodeScalar>()
+        scalars.reserveCapacity(length)
         
         for _ in 0..<length {
             let randomCharacter = NanoIDHelper.randomCharacter(from: alphabet)
-            nanoID.append(randomCharacter)
+            scalars.append(randomCharacter.unicodeScalars.first!)
         }
         
-        return nanoID
+        return String(String.UnicodeScalarView(scalars))
     }

---

26-125: Add documentation and unit tests.

While there are usage examples in comments, the public APIs lack proper documentation:

1. Add documentation comments for public methods explaining parameters, return values, and possible errors
2. Add unit tests to verify:
   • ID generation with different alphabets and sizes
   • Collision probability
   • Performance benchmarks

Would you like me to help generate comprehensive unit tests for this utility?

UTSChatAdapter/Sources/Generator/Schema+Generator.swift (3)

3-16: Consider improving type mapping consistency and flexibility.

The type mapping structure has a few potential issues:

1. The PaginatedResult to PaginatedResultMessage mapping seems too specific and might not work for paginated results of other types.
2. Some mappings like MessageEventPayload to Message suggest inconsistent naming conventions between the schema and implementation.

Consider:

• Making PaginatedResult mapping more generic using generics
• Documenting the reasoning behind naming convention differences

---

41-45: Improve method naming for clarity.

The bigD() function name is not descriptive of its purpose. Consider renaming it to better reflect its functionality.

extension String {
-   func bigD() -> String {
+   func standardizeIdSuffix() -> String {
        replacingOccurrences(of: "Id", with: "ID")
    }
}

---

97-129: Consider using a more standard approach for feature flags.

Using a tilde prefix convention for marking unimplemented features is non-standard and might be error-prone. Consider using feature flags or the standard @available attribute instead.

Some alternatives to consider:

1. Use feature flags in configuration
2. Use @available attribute with a custom platform version
3. Create an explicit ImplementationStatus enum

Would you like me to provide an example implementation for any of these approaches?

UTSChatAdapter/Sources/Adapter/WebSocketWrapper.swift (3)

24-25: Properly close WebSocket when the task is canceled

When the task is canceled and the loop exits, the WebSocket connection remains open. Ensure the webSocket is closed to free resources.

Apply this diff to close the WebSocket after the loop:

         }
+        webSocket.cancel(with: .goingAway, reason: nil)
     }

---

28-28: Review logging of potentially sensitive information

Printing the contents of text may expose sensitive information in logs. Consider redacting or omitting sensitive data.

---

35-38: Consider using Codable for JSON serialization

Manually constructing JSON strings can be error-prone and hard to maintain. Using Codable structs and JSONEncoder improves reliability and readability.

Here's how you might implement it:

struct RoleMessage: Codable {
    let role: String
}

// ...

Task {
    let message = RoleMessage(role: "ADAPTER")
    if let jsonData = try? JSONEncoder().encode(message),
       let jsonString = String(data: jsonData, encoding: .utf8) {
        try await send(text: jsonString)
    }
}

UTSChatAdapter/Sources/Adapter/Utils.swift (2)

164-171: Enhance type checking in jsonString(_:) function

The function may not handle all types correctly and uses fatalError if the type is not JsonSerialisable. Consider improving type checks and handling or extending support for additional types.

---

281-290: Simplify and enhance type casting in PresenceDataWrapper.from

The current implementation checks for specific dictionary types and force casts. Consider using a more flexible approach to handle different data types safely.

Apply this diff for a more robust implementation:

- if value is Dictionary<String, Int64> {
-     return value as! Dictionary<String, Int64>
- }
- else if value is Dictionary<String, String> {
-     return value as! Dictionary<String, String>
- }
- if value is String {
-     return value as! String
- }
- return ""
+ if let presenceData = value as? PresenceData {
+     return presenceData
+ } else {
+     return ""
+ }

UTSChatAdapter/Sources/Generator/ChatAdapterGenerator.swift (2)

11-14: Use a logging framework instead of print statements

The generate() method uses print statements for logging purposes. In production code, it's advisable to use a logging framework to gain better control over logging levels and outputs.

Consider replacing print with a logging mechanism like os_log or a third-party framework to enhance logging capabilities.

---

49-250: Improve code generation maintainability using a templating engine

Building the generatedFileContent by concatenating large strings can make the code hard to read and maintain. Utilizing a templating engine (e.g., Stencil or Sourcery) would simplify the code generation process and improve readability.

Implementing a templating engine can help manage complex code structures and make future modifications easier.

UTSChatAdapter/Sources/Generator/Schema.swift (1)

8-8: Enhance Error Logging by Including Error Details

Including the error details in the print statement can aid in debugging by providing more context about the failure.

Apply this diff:

-            print("Couldn't parse schema JSON.")
+            print("Couldn't parse schema JSON: \(error).")

UTSChatAdapter/Sources/Adapter/ChatAdapter.swift (4)

792-792: Fix typo in error message

The error message in line 792 has a typo: 'tne' should be 'the'.

Apply this diff to correct the typo:

-return "Object of type '\(type)' with tne refId '\(refId)' was not found."
+return "Object of type '\(type)' with the refId '\(refId)' was not found."

---

747-747: Correct typo in comment

The word 'enougth' in the comment should be 'enough'.

Apply this diff to correct the typo:

-// `events` is an array of strings in schema file which is not enougth for param auto-generation (should be `PresenceEventType`)
+// `events` is an array of strings in schema file which is not enough for param auto-generation (should be `PresenceEventType`)

---

772-772: Replace print statements with proper logging

The print statements at lines 772 and 778 should be replaced with an appropriate logging mechanism.

Apply this diff to use a logging framework:

-print("Warning: method `\(method)` was not found") // TODO: use logger
+logger.warning("Method `\(method)` was not found")

-print("Error: \(error)") // TODO: use logger
+logger.error("Error: \(error)")

Ensure that a logging framework is integrated and used consistently throughout the codebase for better log management and configurability.

Also applies to: 778-778

---

726-728: Avoid redundant calls to rpcParams.refId()

The method try rpcParams.refId() is called multiple times. Consider storing the result in a variable to improve efficiency and readability.

Apply this diff:

-case "Message#createdAt":
-    guard let message = idToMessage[try rpcParams.refId()] else {
-        throw AdapterError.objectNotFound(type: "Message", refId: try rpcParams.refId())
-    }
+case "Message#createdAt":
+    let refId = try rpcParams.refId()
+    guard let message = idToMessage[refId] else {
+        throw AdapterError.objectNotFound(type: "Message", refId: refId)
+    }

This pattern can be applied to other cases where try rpcParams.refId() is called multiple times.

UTSChatAdapter/Sources/Generator/main.swift (1)

1-1: 🛠️ Refactor suggestion

Add error handling and logging for the generation process.

The generator should provide feedback about its progress and handle potential failures gracefully.

Consider this improvement:

-ChatAdapterGenerator().generate()
+do {
+    print("Starting chat adapter generation...")
+    try ChatAdapterGenerator().generate()
+    print("Chat adapter generation completed successfully")
+} catch {
+    print("Failed to generate chat adapter: \(error)")
+    exit(1)
+}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

do {
    print("Starting chat adapter generation...")
    try ChatAdapterGenerator().generate()
    print("Chat adapter generation completed successfully")
} catch {
    print("Failed to generate chat adapter: \(error)")
    exit(1)
}

UTSChatAdapter/Sources/Generator/Utils.swift (1)

10-16: 🛠️ Refactor suggestion

Enhance sorting flexibility and add documentation.

The current sorting implementation uses a fixed descending order which might not be suitable for all use cases.

Consider this improved implementation:

 extension JSON {
+    /// Sort dictionary elements by key
+    /// - Parameter ascending: Sort order (default: true for ascending)
+    /// - Returns: Array of key-value pairs sorted by key
-    func sortedByKey() -> Array<Element> {
-        sorted {
-            $0.key > $1.key
-        }
+    func sortedByKey(ascending: Bool = true) -> Array<Element> {
+        sorted { ascending ? $0.key < $1.key : $0.key > $1.key }
     }
 }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

extension JSON {
    /// Sort dictionary elements by key
    /// - Parameter ascending: Sort order (default: true for ascending)
    /// - Returns: Array of key-value pairs sorted by key
    func sortedByKey(ascending: Bool = true) -> Array<Element> {
        sorted { ascending ? $0.key < $1.key : $0.key > $1.key }
    }
}

UTSChatAdapter/Sources/Adapter/main.swift (2)

1-1: ⚠️ Potential issue

Add missing imports for WebSocketWrapper and ChatAdapter

The file uses WebSocketWrapper and ChatAdapter but their imports are missing.

Add the required imports:

 import Foundation
+import WebSocketWrapper
+import ChatAdapter

Committable suggestion skipped: line range outside the PR's diff.

---

3-19: 🛠️ Refactor suggestion

Enhance error handling and add connection management

The WebSocket connection handling could be more robust. Consider the following improvements:

1. Add JSON message validation
2. Implement connection timeout handling
3. Add graceful shutdown mechanism
4. Handle WebSocket connection errors explicitly

Here's a suggested implementation:

 func serve() async throws {
+    let timeout = TimeInterval(30) // 30 seconds timeout
     let webSocket = await WebSocketWrapper()
     var adapter = await ChatAdapter(webSocket: webSocket)
     
+    // Setup shutdown handler
+    Task {
+        await handleShutdown(webSocket: webSocket)
+    }
+    
+    // Validate connection
+    guard try await webSocket.waitForConnection(timeout: timeout) else {
+        throw AdapterError.connectionTimeout
+    }
     
     try await webSocket.start { message in
         do {
+            // Validate JSON-RPC message structure
+            guard try message.isValidJsonRpc() else {
+                throw AdapterError.invalidJsonRpc
+            }
+            
             let params = try message.json()
             print("RPC params: \(params)")
             
             let rpcResponse = try await adapter.handleRpcCall(rpcParams: params)
             try await webSocket.send(text: rpcResponse)
         }
         catch {
-            print("Unhandled exception occured: \(error)") // TODO: replace with logger
+            let errorResponse = JsonRpcError(error: error).response()
+            try? await webSocket.send(text: errorResponse)
         }
     }
 }

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Adapter/Schema+Adapter.swift (1)

44-48: 🛠️ Refactor suggestion

Add access modifier and error handling.

For the subscribeAll method:

1. Consider making it public if it's meant to be used outside the module
2. Add error handling for the async operation
3. Document the behavior and any potential failure scenarios

 extension Presence {
-    func subscribeAll() async -> Subscription<PresenceEvent> {
+    public func subscribeAll() async throws -> Subscription<PresenceEvent> {
         await subscribe(events: [.enter, .leave, .present, .update])
     }
 }

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Adapter/NanoID.swift (2)

113-124: 🛠️ Refactor suggestion

Remove unreachable default case.

The default case in the chars() method is unreachable as all enum cases are explicitly handled. This makes the code less maintainable and could hide bugs when new cases are added.

Apply this diff:

     private func chars() -> String {
         switch self {
         case .uppercasedLatinLetters:
             return "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         case .lowercasedLatinLetters:
             return "abcdefghijklmnopqrstuvwxyz"
         case .numbers:
             return "1234567890"
-        default:
-            return ""
         }
     }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    private func chars() -> String {
        switch self {
        case .uppercasedLatinLetters:
            return "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        case .lowercasedLatinLetters:
            return "abcdefghijklmnopqrstuvwxyz"
        case .numbers:
            return "1234567890"
        }
    }

---

26-62: 🛠️ Refactor suggestion

⚠️ Potential issue

Consider using a more secure random number generator.

The implementation relies on arc4random_uniform (indirectly through NanoIDHelper), which might not be cryptographically secure on all platforms. Consider using SecRandomCopyBytes for better security.

Apply this diff to improve security:

 class NanoID {
+    private static func secureRandom(upperBound: UInt32) -> UInt32 {
+        var randomNumber: UInt32 = 0
+        let status = SecRandomCopyBytes(kSecRandomDefault, MemoryLayout<UInt32>.size, &randomNumber)
+        guard status == errSecSuccess else {
+            // Fallback to arc4random if secure random fails
+            return arc4random_uniform(upperBound)
+        }
+        return randomNumber % upperBound
+    }

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Generator/Schema+Generator.swift (1)

18-31: ⚠️ Potential issue

Fix critical issues in JSON primitive type handling.

There are two issues that need attention:

1. The isJsonPrimitiveType function has a bug in the contains check - it's passing an array [typeName] instead of just typeName.
2. The jsonPrimitiveTypesMap is missing mappings for floating-point numbers.

Apply these fixes:

fileprivate let jsonPrimitiveTypesMap = [
    "string": "\(String.self)",
    "boolean": "\(Bool.self)",
-   "number": "\(Int.self)"
+   "number": "\(Double.self)",
+   "integer": "\(Int.self)"
]

func isJsonPrimitiveType(_ typeName: String) -> Bool {
-   jsonPrimitiveTypesMap.keys.contains([typeName])
+   jsonPrimitiveTypesMap.keys.contains(typeName)
}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

fileprivate let jsonPrimitiveTypesMap = [
    "string": "\(String.self)",
    "boolean": "\(Bool.self)",
    "number": "\(Double.self)",
    "integer": "\(Int.self)"
]

fileprivate let altMethodsMap = [
    "onDiscontinuity": "subscribeToDiscontinuities",
    "subscribe_listener": "subscribeAll",
]

func isJsonPrimitiveType(_ typeName: String) -> Bool {
    jsonPrimitiveTypesMap.keys.contains(typeName)
}

UTSChatAdapter/Sources/Adapter/WebSocketWrapper.swift (4)

8-10: ⚠️ Potential issue

Incorrect use of delegateQueue in URLSession initialization

Using OperationQueue.current for delegateQueue may result in unexpected behavior since it can be nil outside of an OperationQueue. It's safer to specify a dedicated OperationQueue or use OperationQueue.main.

Apply this diff to fix the issue:

- let session = URLSession(configuration: .default, delegate: self, delegateQueue: .current)
+ let session = URLSession(configuration: .default, delegate: self, delegateQueue: .main)

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    func start(onMessage: @escaping (URLSessionWebSocketTask.Message) async throws -> Void) async throws {
        let session = URLSession(configuration: .default, delegate: self, delegateQueue: .main)
        let url = URL(string: "ws://localhost:3000")!

---

19-20: ⚠️ Potential issue

Avoid blocking with sleep in asynchronous code

Using sleep(5) blocks the current thread and is not suitable for asynchronous functions. Instead, use try await Task.sleep(nanoseconds:) to suspend the task without blocking.

Apply this diff to fix the issue:

-                sleep(5) // try again in 5 seconds
+                try await Task.sleep(nanoseconds: 5 * 1_000_000_000) // try again in 5 seconds

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

                print("Can't connect to \(url): \(error.localizedDescription)")
                try await Task.sleep(nanoseconds: 5 * 1_000_000_000) // try again in 5 seconds

---

27-30: ⚠️ Potential issue

Handle possible uninitialized webSocket in send(text:)

Since webSocket is force-unwrapped, calling send(text:) before start() is called or if webSocket is nil will cause a runtime crash. Consider checking if webSocket is initialized.

Apply this diff to handle uninitialized webSocket:

     func send(text: String) async throws {
+        guard webSocket != nil else {
+            throw URLError(.badURL) // Or define a custom error
+        }
         print("Sending: \(text)")
         try await webSocket.send(URLSessionWebSocketTask.Message.string(text))
     }

Committable suggestion skipped: line range outside the PR's diff.

---

21-23: 🛠️ Refactor suggestion

Ensure previous WebSocket task is properly canceled before creating a new one

Before creating a new WebSocket task, the previous task should be canceled to prevent resource leaks or unexpected behavior.

Apply this diff to address the issue:

                 print("Can't connect to \(url): \(error.localizedDescription)")
-                try await Task.sleep(nanoseconds: 5 * 1_000_000_000) // try again in 5 seconds
+                try await Task.sleep(nanoseconds: 5 * 1_000_000_000) // try again in 5 seconds
+                webSocket.cancel(with: .goingAway, reason: nil)
                 webSocket = session.webSocketTask(with: url) // without recreating the task it doesn't work
                 webSocket.resume()

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Adapter/Utils.swift (9)

175-175: 🛠️ Refactor suggestion

Implement the from method or handle the unimplemented case properly

The from method currently contains a fatalError("Not implemented"), which will crash at runtime if called. Implement the method or throw a meaningful error.

Would you like assistance in implementing the from method for Message? I can help provide a basic implementation.

---

223-224: ⚠️ Potential issue

Correct the assignment to avoid overwriting presence.enter

The code assigns presence.enter twice, potentially overwriting the first value. Likely, the second assignment should be to presence.subscribe.

Apply this diff to fix the issue:

    presence.enter = presenceJson["enter"] as? Bool ?? false
-   presence.enter = presenceJson["subscribe"] as? Bool ?? false
+   presence.subscribe = presenceJson["subscribe"] as? Bool ?? false

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

            presence.enter = presenceJson["enter"] as? Bool ?? false
            presence.subscribe = presenceJson["subscribe"] as? Bool ?? false

---

257-257: ⚠️ Potential issue

Safely unwrap optionals when extracting logLevel

Force casting json["logLevel"] as! String can cause a crash if logLevel is missing or not a String. Use safe unwrapping to handle potential errors.

Apply this diff to fix the issue:

- options.logLevel = .from(string: json["logLevel"] as! String)
+ if let logLevelString = json["logLevel"] as? String {
+     options.logLevel = .from(string: logLevelString)
+ } else {
+     options.logLevel = .debug // or a default value
+ }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        if let logLevelString = json["logLevel"] as? String {
            options.logLevel = .from(string: logLevelString)
        } else {
            options.logLevel = .debug // or a default value
        }

---

269-269: ⚠️ Potential issue

Handle missing or invalid environment key safely

Force casting json["environment"] as! String may crash if environment is nil or not a String. Safely unwrap and provide a default or handle the error.

Apply this diff to fix the issue:

- options.environment = json["environment"] as! String
+ guard let environment = json["environment"] as? String else {
+     fatalError("Expected 'environment' to be a String in ARTClientOptions")
+ }
+ options.environment = environment

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        guard let environment = json["environment"] as? String else {
            fatalError("Expected 'environment' to be a String in ARTClientOptions")
        }
        options.environment = environment

---

271-271: ⚠️ Potential issue

Ensure safe casting when setting logLevel

Casting json["logLevel"] as! UInt can crash if the value is not present or not a UInt. Safely unwrap and validate the value.

Apply this diff to fix the issue:

- options.logLevel = .init(rawValue: json["logLevel"] as! UInt) ?? .debug
+ if let logLevelRaw = json["logLevel"] as? UInt,
+    let logLevel = ARTLogLevel(rawValue: logLevelRaw) {
+     options.logLevel = logLevel
+ } else {
+     options.logLevel = .debug // or handle the error accordingly
+ }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        if let logLevelRaw = json["logLevel"] as? UInt,
            let logLevel = ARTLogLevel(rawValue: logLevelRaw) {
             options.logLevel = logLevel
        } else {
             options.logLevel = .debug // or handle the error accordingly
        }

---

68-70: ⚠️ Potential issue

Avoid force unwrapping optionals to prevent runtime crashes

Using string.data(using: .utf8)! force unwraps an optional, which can cause a runtime crash if the conversion fails. Instead, safely unwrap the optional to handle potential nil values.

Apply this diff to fix the issue:

- json = try JSONSerialization.jsonObject(with: string.data(using: .utf8)!) as? JSON
+ guard let data = string.data(using: .utf8) else {
+     throw RPCError.invalidJSON
+ }
+ json = try JSONSerialization.jsonObject(with: data) as? JSON

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

            json = try JSONSerialization.jsonObject(with: data) as? [String: Any]
        case .string(let string):
            guard let data = string.data(using: .utf8) else {
                throw RPCError.invalidJSON
            }
            json = try JSONSerialization.jsonObject(with: data) as? JSON

---

105-105: ⚠️ Potential issue

Escape strings properly when constructing JSON strings

When building JSON strings manually, ensure that special characters in reason are properly escaped to prevent invalid JSON.

Apply this diff to fix the issue using JSONSerialization:

- "{\"code\": \(code), \"statusCode\": \(statusCode), \"reason\": \"\(reason ?? description)\"}"
+ let jsonDict: [String: Any] = [
+     "code": code,
+     "statusCode": statusCode,
+     "reason": reason ?? description
+ ]
+ let data = try? JSONSerialization.data(withJSONObject: jsonDict)
+ let jsonString = String(data: data!, encoding: .utf8)!
+ return jsonString

Committable suggestion skipped: line range outside the PR's diff.

---

39-39: ⚠️ Potential issue

Safely serialize ErrorInfo to JSON to handle special characters

Directly inserting error.description into a JSON string may result in invalid JSON if the description contains special characters. Use JSONSerialization or JSONEncoder to ensure proper escaping.

Apply this diff to fix the issue:

- return "{\"jsonrpc\":\"2.0\",\"id\":\"\(requestId)\",\"error\":{\"message\": \"\(error.description)\", \"data\": {\"ablyError\": true, \"errorInfo\": \(error.jsonString())}}}"
+ let errorDict: [String: Any] = [
+     "jsonrpc": "2.0",
+     "id": requestId,
+     "error": [
+         "message": error.description,
+         "data": [
+             "ablyError": true,
+             "errorInfo": error.jsonString()
+         ]
+     ]
+ ]
+ let data = try? JSONSerialization.data(withJSONObject: errorDict)
+ return String(data: data!, encoding: .utf8)!

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        let errorDict: [String: Any] = [
            "jsonrpc": "2.0",
            "id": requestId,
            "error": [
                "message": error.description,
                "data": [
                    "ablyError": true,
                    "errorInfo": error.jsonString()
                ]
            ]
        ]
        let data = try? JSONSerialization.data(withJSONObject: errorDict)
        return String(data: data!, encoding: .utf8)!

---

194-195: ⚠️ Potential issue

Avoid force casting to prevent runtime crashes

Force casting json["text"] as! String can lead to a runtime crash if the value is nil or not a String. Safely unwrap the optional and handle the error appropriately.

Apply this diff to fix the issue:

- return SendMessageParams(text: json["text"] as! String)
+ guard let text = json["text"] as? String else {
+     fatalError("Expected 'text' to be a String in SendMessageParams")
+ }
+ return SendMessageParams(text: text)

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Generator/ChatAdapterGenerator.swift (2)

74-75: ⚠️ Potential issue

Avoid force casting (as!) and force unwrapping (!) to prevent runtime crashes

In multiple places, the code uses force casting and force unwrapping, which can lead to runtime exceptions if the cast fails or an optional is nil. Specifically:

• Line 74: let argSchema = $0.value as! JSON
• Line 215: let argType = ($0.value as! JSON).type!
• Line 258: var result: JSON { self["result"] as! JSON }

Consider using safe casting (as?) and optional binding (if let or guard let) to handle these cases gracefully.

Apply this diff to safely unwrap and cast values:

- let argSchema = $0.value as! JSON
+ guard let argSchema = $0.value as? JSON else {
+     return print("Invalid argument schema for \($0.key).")
+ }

- let argType = ($0.value as! JSON).type!
+ guard let argValue = $0.value as? JSON, let argType = argValue.type else {
+     return print("Invalid argument type for \($0.key).")
+ }

- var result: JSON { self["result"] as! JSON }
+ var result: JSON? { self["result"] as? JSON }

Ensure that the rest of the code handles optional values appropriately to prevent unexpected crashes.

Also applies to: 215-216, 258-259

---

226-240: 🛠️ Refactor suggestion

Refactor generateCallback to safely handle optionals and improve readability

In the generateCallback method, the current implementation force unwraps optionals, which can lead to crashes if values are nil. Specifically:

• Line 226: (callbackArgs.first?.value as? JSON)?.isOptional ?? false

Consider safely unwrapping these optionals to enhance code safety and readability.

Apply this diff to refactor the code:

- if (callbackArgs.first?.value as? JSON)?.isOptional ?? false {
+ if let firstArgValue = callbackArgs.first?.value as? JSON, firstArgValue.isOptional {
      // Handle the optional parameter case
  } else {
      // Handle the non-optional parameter case
  }

This ensures that you're only accessing properties on non-nil values, preventing potential runtime exceptions.

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Generator/Schema.swift (1)

5-11: ⚠️ Potential issue

Avoid Force Unwrapping Optionals to Prevent Runtime Crashes

Using ! to force unwrap optionals can lead to runtime crashes if the value is nil. It's safer to use optional binding with guard let or if let to handle potential failures gracefully.

Apply this diff to fix the issue:

do {
-    return try JSONSerialization.jsonObject(with: Self.content.data(using: .utf8)!) as! [JSON]
+    guard let data = Self.content.data(using: .utf8) else {
+        print("Couldn't convert content to data.")
+        return []
+    }
+    let jsonObject = try JSONSerialization.jsonObject(with: data)
+    guard let jsonArray = jsonObject as? [JSON] else {
+        print("JSON is not in expected format.")
+        return []
+    }
+    return jsonArray
} catch {
    print("Couldn't parse schema JSON.")
    return []
}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        do {
            guard let data = Self.content.data(using: .utf8) else {
                print("Couldn't convert content to data.")
                return []
            }
            let jsonObject = try JSONSerialization.jsonObject(with: data)
            guard let jsonArray = jsonObject as? [JSON] else {
                print("JSON is not in expected format.")
                return []
            }
            return jsonArray
        } catch {
            print("Couldn't parse schema JSON.")
            return []
        }

UTSChatAdapter/Sources/Adapter/ChatAdapter.swift (1)

777-779: ⚠️ Potential issue

Handle potential error when retrieving requestId in catch block

In the catch block, calling try rpcParams.requestId() might fail if rpcParams is invalid or incomplete, potentially leading to an unhandled error. Consider safely retrieving requestId or providing a default error response.

Apply this diff to safeguard against errors:

catch {
-    print("Error: \(error)") // TODO: use logger
-    return jsonRpcError(try rpcParams.requestId(), error: error)
+    logger.error("Error: \(error)")
+    let requestId = (try? rpcParams.requestId()) ?? "unknown"
+    return jsonRpcError(requestId, error: error)
}

This ensures that even if requestId cannot be retrieved, the error response can still be sent without causing a crash.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

            logger.error("Error: \(error)")
            let requestId = (try? rpcParams.requestId()) ?? "unknown"
            return jsonRpcError(requestId, error: error)
        }

UTSChatAdapter/Sources/Adapter/NanoID.swift (2)

1-25: Add proper attribution and improve documentation format.

The code appears to be derived from third-party work. Please ensure:

1. Proper attribution and license compliance
2. Convert usage examples to Swift-style documentation format using /// and markdown

Example format:

-/// USAGE
-///
-/// Nano ID with default alphabet (0-9a-zA-Z_~) and length (21 chars)
-/// let id = NanoID.new()
+/// Generates unique identifiers with customizable alphabets and lengths.
+///
+/// Example usage:
+/// ```swift
+/// // Generate ID with default alphabet (0-9a-zA-Z_~) and length (21 chars)
+/// let id = NanoID.new()
+/// ```

---

64-96: Optimize string operations for better performance.

The current implementation could be optimized by:

1. Pre-allocating string capacity
2. Using a more efficient string building approach

Suggested optimization:

 static func generate(from alphabet: String, of length: Int) -> String {
-    var nanoID = ""
+    var nanoID = String()
+    nanoID.reserveCapacity(length)
     
     for _ in 0..<length {
         let randomCharacter = NanoIDHelper.randomCharacter(from: alphabet)
         nanoID.append(randomCharacter)
     }
     
     return nanoID
 }

UTSChatAdapter/Sources/Adapter/Utils.swift (1)

281-291: Simplify PresenceDataWrapper.from(_:) method

The method checks the type of value against multiple specific dictionary types. Consider simplifying the method by using Any directly or by validating the acceptable types more generally.

Apply this diff to simplify type checking:

static func from(_ value: Any?) -> PresenceData {
    if let presenceData = value as? PresenceData {
        return presenceData
    }
    // Handle other cases or throw an error
    return ""
}

UTSChatAdapter/Sources/Generator/ChatAdapterGenerator.swift (5)

40-42: Replace 'print' statements with appropriate error handling

In these sections, print is used to indicate unimplemented paths or required custom implementations. It's better to handle these cases using proper error mechanisms to inform the calling code of the unimplemented features.

Suggested change at lines 40-42:

- if Schema.skipPaths.contains([implPath]) {
-     return print("\(implPath) was not yet implemented or requires custom implementation.")
- }
+ if Schema.skipPaths.contains([implPath]) {
+     throw AdapterError.unimplementedPath("\(implPath) requires custom implementation.")
+ }

Apply similar changes at lines 68-70, 131-133, and 171-173, defining AdapterError.unimplementedPath as needed.

Also applies to: 68-70, 131-133, 171-173

---

38-64: Refactor common code to reduce duplication

The methods generateConstructorForType and generateMethodForType share similar logic and structure. Refactoring common functionality into shared helper methods can improve maintainability and reduce code duplication.

Consider creating helper methods for:

• Parameter declaration generation
• Call parameter assembly
• Result handling logic

Also applies to: 66-124

---

213-214: Modify callback handling to support multiple parameters

Currently, the callback generation simplifies to handling only one parameter by using callbackArgs.prefix(1). This could be limiting for callbacks that require multiple arguments.

Suggested change:

- let paramsSignatures = callbackArgs.prefix(1).compactMap { // code below simplifies it to just one callback parameter
+ let paramsSignatures = callbackArgs.compactMap {

Adjust the subsequent code in generateCallback to handle all callback arguments appropriately.

---

254-267: Namespace JSON extensions to prevent conflicts

Adding computed properties directly to the JSON type may cause conflicts if other parts of the codebase or third-party libraries extend JSON. Consider namespacing these extensions or using a wrapper type.

Example:

extension JSONAdapterExtensions where Base == JSON {
    var name: String? { base["name"] as? String }
    // Other properties...
}

This approach avoids polluting the global JSON namespace.

---

95-101: Streamline JSON serialization for response generation

The serialization logic for JSON primitive types and complex objects is handled differently in multiple places. Consolidating this into a single utility function can simplify the code and reduce redundancy.

Suggested approach:

Create a function like serializeResponse(_:) to handle both primitive and complex types, which checks the type and returns the appropriate JSON string.

func serializeResponse(_ value: Any) -> String {
    if let primitiveValue = value as? PrimitiveType {
        return "{\\"response\\": \\"\\(primitiveValue)\\"}"
    } else {
        return "{\\"response\\": \\(jsonString(value))}"
    }
}

Then use this function in the relevant sections.

Also applies to: 145-151

UTSChatAdapter/Sources/Adapter/ChatAdapter.swift (2)

793-793: Typo in error message: 'tne' should be 'the'

There's a typo in the error message on line 793. The word 'tne' should be corrected to 'the' for clarity.

---

747-747: Typo in comment: 'enougth' should be 'enough'

In the comment on line 747, 'enougth' is misspelled. It should be 'enough'.

Configuration used: CodeRabbit UI
Review profile: CHILL

.github/workflows/unified-test-suite.yml (2)

23-24: Consider using local package installation

Global package installation in CI environments can lead to versioning conflicts and pollution of the global npm space. Consider installing the package locally or using npx to run it directly.

Apply this diff:

-      - name: Install uts-chat globally
-        run: npm install -g @ably-labs/uts-chat
+      - name: Install uts-chat
+        run: npm install @ably-labs/uts-chat

---

26-30: Document Xcode version requirement

The comment indicates this step is temporary, but it's important to document the minimum Xcode version requirement in the project's README or documentation.

Configuration used: CodeRabbit UI
Review profile: CHILL

UTSChatAdapter/Sources/Adapter/Schema+Adapter.swift (4)

4-5: Consider consolidating redundant type aliases

ErrorInfo and AblyErrorInfo are both aliased to ARTErrorInfo. This redundancy could lead to confusion. Consider keeping only one of these aliases to maintain a single source of truth.

 typealias ErrorInfo = ARTErrorInfo
-typealias AblyErrorInfo = ARTErrorInfo

---

16-16: Document or implement the empty struct

The purpose of PresenceDataWrapper is unclear. If this is a placeholder for future implementation, please add documentation explaining its intended use. If it's not needed, consider removing it.

---

36-42: Add error handling documentation for async operations

The async methods should include documentation describing:

1. The possible error cases
2. The meaning of nil returns
3. Any preconditions for successful execution

 extension PaginatedResult {
+    /// Returns true if there are more results available
     func hasNext() -> Bool { hasNext }
+    /// Returns true if this is the last page of results
     func isLast() -> Bool { isLast }
+    /// Asynchronously fetches the next page of results
+    /// - Throws: Network errors or invalid pagination state
+    /// - Returns: The next page of results, or nil if no more results exist
     func next() async throws -> (any PaginatedResult<T>)? { try await next }

---

44-48: Consider parameterizing presence event types

The subscribeAll method hard-codes the event types. Consider making it more flexible by allowing callers to specify which events they want to subscribe to.

 extension Presence {
-    func subscribeAll() async -> Subscription<PresenceEvent> {
-        await subscribe(events: [.enter, .leave, .present, .update])
+    /// Subscribe to specified presence events
+    /// - Parameter events: Array of presence events to subscribe to. Defaults to all events.
+    /// - Returns: A subscription for the specified presence events
+    func subscribeAll(events: [PresenceEvent.Kind] = [.enter, .leave, .present, .update]) async -> Subscription<PresenceEvent> {
+        await subscribe(events: events)
     }
 }

UTSChatAdapter/Sources/Adapter/NanoID.swift (1)

43-44: Document rationale for default parameters

Add documentation explaining why 21 characters and URL-safe alphabet were chosen as defaults. This helps future maintainers understand the security and compatibility considerations.

UTSChatAdapter/Sources/Generator/Schema.swift (1)

14-994: Consider improving schema management and documentation

The current implementation has several architectural concerns:

1. Schema is hardcoded as a large string literal, making it difficult to maintain
2. No versioning information for schema compatibility
3. Missing documentation for schema format and validation

Consider these improvements:

1. Move schema to a separate JSON file and load it at runtime
2. Add version field to track schema changes
3. Add documentation for schema format
4. Add validation for required fields

Example implementation:

// Schema.swift
enum Schema {
    /// Schema version for compatibility checking
    static let version = "1.0.0"
    
    /// Path to schema file relative to bundle
    private static let schemaFile = "chat_schema.json"
    
    static var json: [JSON] {
        do {
            guard let url = Bundle.module.url(forResource: schemaFile, withExtension: nil),
                  let data = try? Data(contentsOf: url),
                  let parsed = try JSONSerialization.jsonObject(with: data) as? [JSON]
            else {
                print("Failed to load schema file")
                return []
            }
            
            // Validate schema version
            guard let schemaVersion = parsed.first?["version"] as? String,
                  schemaVersion == version
            else {
                print("Schema version mismatch")
                return []
            }
            
            return parsed
        } catch {
            print("Failed to parse schema: \(error)")
            return []
        }
    }
}

Would you like me to help create a separate issue to track these improvements?

UTSChatAdapter/Sources/Adapter/WebSocketWrapper.swift (2)

9-9: Make the WebSocket URL configurable

Hardcoding the WebSocket URL limits flexibility and makes it difficult to connect to different servers or environments. Consider injecting the URL via an initializer parameter or configuration file to allow for better adaptability.

Example of making the URL configurable:

final class WebSocketWrapper: NSObject, URLSessionWebSocketDelegate {
    private var webSocket: URLSessionWebSocketTask?
    private let url: URL

    init(url: URL) {
        self.url = url
    }

    // ...
}

---

18-22: Enhance error handling and reconnection logic

Recreating the webSocket task upon any error may not be optimal, as some errors might be recoverable without restarting the connection. Additionally, the previous webSocket task should be canceled to prevent resource leaks. Consider refining the error handling to distinguish between different error types and ensure proper cleanup.

Example modification:

catch {
    print("Connection error: \(error.localizedDescription). Retrying in 5 seconds...")
    webSocket.cancel()
    try await Task.sleep(nanoseconds: 5 * 1_000_000_000)
    webSocket = session.webSocketTask(with: url)
    webSocket.resume()
}

UTSChatAdapter/Sources/Adapter/Schema+Adapter.swift (1)

18-30: 🛠️ Refactor suggestion

Add documentation and parameter validation

The message comparison methods lack documentation and parameter validation. Consider:

1. Adding documentation explaining the comparison logic
2. Validating the input parameter for null/invalid values

 public extension Message {
+    /// Checks if the current message occurred before the given message
+    /// - Parameter message: The message to compare against
+    /// - Throws: If either message is invalid or comparison fails
+    /// - Returns: true if the current message is before the given message
     func before(message: Message) throws -> Bool {
+        guard message.id != nil else {
+            throw ErrorInfo(code: 40000, message: "Invalid message: missing id")
+        }
         try isBefore(message)
     }

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Adapter/NanoID.swift (5)

110-121: 🛠️ Refactor suggestion

Improve enum implementation

Several improvements needed:

1. Remove unnecessary default case
2. Define character sets as static constants
3. Add validation for duplicate characters in urlSafe case

Apply this diff:

+    private static let UPPERCASE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    private static let LOWERCASE_CHARS = "abcdefghijklmnopqrstuvwxyz"
+    private static let NUMBER_CHARS = "1234567890"
+    private static let SPECIAL_CHARS = "~_"
+
     private func chars() -> String {
         switch self {
         case .uppercasedLatinLetters:
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            Self.UPPERCASE_CHARS
         case .lowercasedLatinLetters:
-            "abcdefghijklmnopqrstuvwxyz"
+            Self.LOWERCASE_CHARS
         case .numbers:
-            "1234567890"
+            Self.NUMBER_CHARS
-        default:
-            ""
         }
     }

Committable suggestion skipped: line range outside the PR's diff.

---

51-55: ⚠️ Potential issue

Add input validation in static factory method

The static new(alphabet:size:) method should validate its inputs similar to the instance initializer.

Apply this diff:

 static func new(alphabet: NanoIDAlphabet..., size: Int) -> String {
+    guard size > 0 else {
+        preconditionFailure("Size must be greater than 0")
+    }
+    guard !alphabet.isEmpty else {
+        preconditionFailure("Alphabet must not be empty")
+    }
     let charactersString = NanoIDHelper.parse(alphabet)
+    guard !charactersString.isEmpty else {
+        preconditionFailure("Parsed alphabet must not be empty")
+    }
     return NanoIDHelper.generate(from: charactersString, of: size)
 }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    /// Generates a Nano ID using given occasional parameters
    static func new(alphabet: NanoIDAlphabet..., size: Int) -> String {
        guard size > 0 else {
            preconditionFailure("Size must be greater than 0")
        }
        guard !alphabet.isEmpty else {
            preconditionFailure("Alphabet must not be empty")
        }
        let charactersString = NanoIDHelper.parse(alphabet)
        guard !charactersString.isEmpty else {
            preconditionFailure("Parsed alphabet must not be empty")
        }
        return NanoIDHelper.generate(from: charactersString, of: size)
    }

---

32-35: ⚠️ Potential issue

Add input validation in initializer

The initializer should validate its inputs to prevent runtime issues:

1. Validate that size is positive
2. Ensure alphabet array is not empty
3. Check for and handle duplicate characters in the alphabet

Apply this diff:

 init(alphabet: NanoIDAlphabet..., size: Int) {
+    guard size > 0 else {
+        preconditionFailure("Size must be greater than 0")
+    }
+    guard !alphabet.isEmpty else {
+        preconditionFailure("Alphabet must not be empty")
+    }
     self.size = size
     self.alphabet = NanoIDHelper.parse(alphabet)
+    guard !self.alphabet.isEmpty else {
+        preconditionFailure("Parsed alphabet must not be empty")
+    }
 }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    init(alphabet: NanoIDAlphabet..., size: Int) {
        guard size > 0 else {
            preconditionFailure("Size must be greater than 0")
        }
        guard !alphabet.isEmpty else {
            preconditionFailure("Alphabet must not be empty")
        }
        self.size = size
        self.alphabet = NanoIDHelper.parse(alphabet)
        guard !self.alphabet.isEmpty else {
            preconditionFailure("Parsed alphabet must not be empty")
        }
    }

---

88-92: ⚠️ Potential issue

Replace arc4random_uniform with SecRandomCopyBytes

Using arc4random_uniform for cryptographic purposes is not secure. Use SecRandomCopyBytes instead for better security.

Apply this diff:

 static func randomCharacter(from string: String) -> Character {
-    let randomNum = Int(arc4random_uniform(UInt32(string.count)))
+    var bytes = [UInt8](repeating: 0, count: 1)
+    guard SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) == errSecSuccess else {
+        preconditionFailure("Failed to generate secure random number")
+    }
+    let randomNum = Int(bytes[0]) % string.count
     let randomIndex = string.index(string.startIndex, offsetBy: randomNum)
     return string[randomIndex]
 }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    static func randomCharacter(from string: String) -> Character {
        var bytes = [UInt8](repeating: 0, count: 1)
        guard SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) == errSecSuccess else {
            preconditionFailure("Failed to generate secure random number")
        }
        let randomNum = Int(bytes[0]) % string.count
        let randomIndex = string.index(string.startIndex, offsetBy: randomNum)
        return string[randomIndex]
    }

---

1-122: 💡 Codebase verification

Add test coverage for NanoID implementation

The verification reveals:

1. No test directory exists in UTSChatAdapter
2. NanoID is used for ID generation in Utils.swift but lacks test coverage
3. The implementation includes critical functionality (random generation, character sets) that should be tested for reliability

Please add tests to cover:

• Basic functionality of NanoID.new() with default parameters
• Custom alphabet and size combinations
• Validation of generated IDs against specified character sets
• Edge cases (empty alphabet, zero size)
• Random number generation reliability

Create tests in a new directory: UTSChatAdapter/Tests/AdapterTests/

🔗 Analysis chain

Add comprehensive test coverage

Please add unit tests to verify:

1. Input validation
2. Random number generation
3. Collision probability
4. Character set handling
5. Edge cases

Run the following script to check for existing test coverage:

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Description: Check test coverage for NanoID implementation

# Find test files
echo "Looking for NanoID test files..."
fd -e swift "test|Test" | rg -i "nano"

# Check test references
echo "Checking test references to NanoID..."
rg "NanoID" -t swift -g "*test*" -A 3

Length of output: 385

---

Script:

#!/bin/bash
# Let's try a broader search for test files first
echo "Looking for test directories and files..."
fd -t d "test" -i
fd -t f -e swift

# Then check for any NanoID related files
echo -e "\nSearching for NanoID related files..."
rg -l "NanoID" -t swift

# Look for potential test frameworks/patterns
echo -e "\nChecking for test framework patterns..."
rg -l "XCTest|@testable" -t swift

Length of output: 5038

---

Script:

#!/bin/bash
# Let's check if there are any tests for NanoID in UTSChatAdapter directory
echo "Checking for NanoID tests in UTSChatAdapter..."
fd -t d "test" -i -p "UTSChatAdapter"

# Check how NanoID is used in Utils.swift since it references it
echo -e "\nChecking NanoID usage in Utils.swift..."
rg "NanoID" UTSChatAdapter/Sources/Adapter/Utils.swift -C 3

# Look for any test files in UTSChatAdapter
echo -e "\nLooking for test files in UTSChatAdapter..."
fd -e swift -p "UTSChatAdapter" | rg -i "test"

Length of output: 556

UTSChatAdapter/Sources/Generator/Schema.swift (2)

4-11: ⚠️ Potential issue

Improve error handling and avoid force unwrapping

The current implementation has several issues:

1. Force unwrapping (!) can lead to runtime crashes
2. Error handling is too basic and loses error context
3. No validation of parsed content

Consider this safer implementation:

 static var json: [JSON] {
     do {
-        return try JSONSerialization.jsonObject(with: content.data(using: .utf8)!) as! [JSON]
+        guard let data = content.data(using: .utf8) else {
+            print("Failed to encode schema content as UTF-8")
+            return []
+        }
+        guard let parsed = try JSONSerialization.jsonObject(with: data) as? [JSON] else {
+            print("Failed to parse schema JSON: invalid format")
+            return []
+        }
+        return parsed
     } catch {
-        print("Couldn't parse schema JSON.")
+        print("Failed to parse schema JSON: \(error)")
         return []
     }
 }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    static var json: [JSON] {
        do {
            guard let data = content.data(using: .utf8) else {
                print("Failed to encode schema content as UTF-8")
                return []
            }
            guard let parsed = try JSONSerialization.jsonObject(with: data) as? [JSON] else {
                print("Failed to parse schema JSON: invalid format")
                return []
            }
            return parsed
        } catch {
            print("Failed to parse schema JSON: \(error)")
            return []
        }
    }

---

944-947: 💡 Codebase verification

Schema's serialization configuration for TypingEvent should be true

The TypingEvent is explicitly required to be serializable in the codebase:

• It implements the JsonSerialisable protocol in UTSChatAdapter/Sources/Adapter/Utils.swift
• It's used in WebSocket communication where the adapter serializes it to JSON in ChatAdapter.swift
• The current schema marking it as "serializable": false contradicts the actual implementation and usage

🔗 Analysis chain

Verify serialization configuration for TypingEvent

The TypingEvent type in the subscription callback is marked as non-serializable, but it appears to be used in a context where serialization might be needed for event handling.

---

Let me analyze the findings. The search results show that TypingEvent is used in several contexts:

1. It's defined as a simple struct in Sources/AblyChat/Typing.swift containing just a set of strings
2. It's used in subscriptions and mock implementations
3. It implements JsonSerialisable in UTSChatAdapter/Sources/Adapter/Utils.swift
4. The schema marks it as non-serializable, but the adapter actually needs to serialize it for WebSocket communication

Let me verify one more aspect about the serialization implementation:

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Search for TypingEvent usage to verify serialization requirements
rg "TypingEvent" -A 5 -B 5

Length of output: 8481

---

Script:

#!/bin/bash
# Check the JsonSerialisable protocol definition and implementation
rg "JsonSerialisable" -A 5 -B 5

Length of output: 5959

UTSChatAdapter/Sources/Adapter/WebSocketWrapper.swift (6)

5-5: ⚠️ Potential issue

Avoid using implicitly unwrapped optionals for webSocket

Declaring webSocket as an implicitly unwrapped optional (URLSessionWebSocketTask!) can lead to runtime crashes if it's accessed before being initialized. Consider defining it as an optional and safely unwrapping it where necessary.

Apply this diff to address the issue:

-private var webSocket: URLSessionWebSocketTask!
+private var webSocket: URLSessionWebSocketTask?

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    private var webSocket: URLSessionWebSocketTask?

---

8-8: ⚠️ Potential issue

Review the use of .current for delegateQueue

Using .current for delegateQueue may not behave as expected if there's no current OperationQueue. This could lead to delegate callbacks not being executed on the correct thread. Consider specifying nil to use the default delegate queue or creating a dedicated OperationQueue.

Apply this diff to specify the default delegate queue:

-let session = URLSession(configuration: .default, delegate: self, delegateQueue: .current)
+let session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        let session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)

---

33-38: ⚠️ Potential issue

Ensure correct actor isolation when calling send(text:) from nonisolated context

Since send(text:) is actor-isolated to the MainActor, calling it from a nonisolated method requires explicit coordination to maintain thread safety. Use await MainActor.run to execute the send operation on the main actor.

Apply this diff to ensure proper actor isolation:

Task {
-   do {
-       try await send(text: "{\"role\":\"ADAPTER\"}")
-   } catch {
-       print("Failed to send initial message: \(error.localizedDescription)")
-   }
+   await MainActor.run {
+       Task {
+           do {
+               try await self.send(text: "{\"role\":\"ADAPTER\"}")
+           } catch {
+               print("Failed to send initial message: \(error.localizedDescription)")
+           }
+       }
+   }
}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    nonisolated func urlSession(_: URLSession, webSocketTask _: URLSessionWebSocketTask, didOpenWithProtocol _: String?) {
        print("Connected to server")
        Task {
            await MainActor.run {
                Task {
                    do {
                        try await self.send(text: "{\"role\":\"ADAPTER\"}")
                    } catch {
                        print("Failed to send initial message: \(error.localizedDescription)")
                    }
                }
            }
        }
    }

---

33-38: ⚠️ Potential issue

Handle errors when sending the initial message in didOpenWithProtocol

The send(text:) method is async throws, but the current implementation does not handle potential errors. This could lead to unhandled exceptions if the message fails to send. Wrap the call in a do-catch block to handle errors appropriately.

Apply this diff to handle errors:

Task {
-   try await send(text: "{\"role\":\"ADAPTER\"}")
+   do {
+       try await send(text: "{\"role\":\"ADAPTER\"}")
+   } catch {
+       print("Failed to send initial message: \(error.localizedDescription)")
+   }
}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    nonisolated func urlSession(_: URLSession, webSocketTask _: URLSessionWebSocketTask, didOpenWithProtocol _: String?) {
        print("Connected to server")
        Task {
            do {
                try await send(text: "{\"role\":\"ADAPTER\"}")
            } catch {
                print("Failed to send initial message: \(error.localizedDescription)")
            }
        }
    }

---

19-19: ⚠️ Potential issue

Use Task.sleep instead of sleep in async context

Calling sleep(5) blocks the current thread, which is not appropriate in an async context and can lead to performance issues. Replace it with try await Task.sleep(nanoseconds:) to suspend the task without blocking the thread.

Apply this diff to fix the issue:

-print("Can't connect to \(url): \(error.localizedDescription)")
-sleep(5) // try again in 5 seconds
+print("Connection error: \(error.localizedDescription). Retrying in 5 seconds...")
+try await Task.sleep(nanoseconds: 5 * 1_000_000_000) // try again in 5 seconds

Committable suggestion skipped: line range outside the PR's diff.

---

26-28: ⚠️ Potential issue

Ensure webSocket is connected before sending messages

Before attempting to send a message, verify that webSocket is not nil and is in the connected state to prevent potential crashes or unexpected behavior.

Apply this diff to add a safety check:

func send(text: String) async throws {
    print("Sending: \(text)")
+   guard let webSocket = webSocket else {
+       throw URLError(.notConnectedToInternet)
+   }
    try await webSocket.send(.string(text))
}

Committable suggestion skipped: line range outside the PR's diff.

UTSChatAdapter/Sources/Adapter/ChatAdapter.swift (4)

810-810: Fix typographical error in error message

There's a typo in the error description string: "tne" should be "the".

Apply this diff to correct the typo:

- "Object of type '\(type)' with tne refId '\(refId)' was not found."
+ "Object of type '\(type)' with the refId '\(refId)' was not found."

---

747-747: Correct typo in comment: 'enougth' should be 'enough'

In the comment on line 747, "enougth" is misspelled. Correcting this improves code readability.

Apply this diff:

- // `events` is an array of strings in schema file which is not enougth for param auto-generation (should be `PresenceEventType`)
+ // `events` is an array of strings in schema file which is not enough for param auto-generation (should be `PresenceEventType`)

---

55-55: Use JSON encoding instead of manual string interpolation

Throughout the code, JSON responses are constructed using manual string interpolation, which can lead to errors if the data contains special characters. It's safer and more robust to use JSON serialization.

For example, replace:

return try jsonRpcResult(rpcParams.requestId(), "{\"refId\":\"\(fieldRefId)\"}")

With:

let responseData = try JSONEncoder().encode(["refId": fieldRefId])
let responseString = String(data: responseData, encoding: .utf8)!
return try jsonRpcResult(rpcParams.requestId(), responseString)

This ensures that all strings are properly escaped and the JSON is valid. Applying this change to all similar instances improves code reliability.

Also applies to: 65-65, 75-75, 101-101, 137-137, 145-145, 153-153, 161-161, 169-169, 177-177, 187-187, 198-198, 209-209, 247-247, 295-295, 318-318, 335-335, 338-338, 347-347, 358-358, 367-367, 376-376, 402-402, 411-411, 421-421, 440-440, 463-463, 472-472, 501-501, 524-524, 540-540, 548-548, 576-576, 606-606, 616-616, 641-641, 649-649, 657-657, 667-667, 686-686, 709-709, 722-722, 730-730, 732-732

---

47-788: Consider refactoring to reduce repetitive code in switch cases

Many cases in the handleRpcCall method share similar patterns of retrieving the refId, fetching objects from dictionaries, and handling errors. Refactoring this pattern can enhance code maintainability and readability.

Introduce a generic helper function:

func getObject<T>(from dict: [String: T], refId: String, typeName: String) throws -> T {
    guard let obj = dict[refId] else {
        throw AdapterError.objectNotFound(type: typeName, refId: refId)
    }
    return obj
}

Then, update the cases. For example, replace:

let refId = try rpcParams.refId()
guard let chatClientRef = idToChatClient[refId] else {
    throw AdapterError.objectNotFound(type: "ChatClient", refId: refId)
}

With:

let refId = try rpcParams.refId()
let chatClientRef = try getObject(from: idToChatClient, refId: refId, typeName: "ChatClient")

This refactoring reduces duplication and simplifies each case, making the codebase easier to manage.

Configuration used: CodeRabbit UI
Review profile: CHILL